import { RouteRecordRaw } from "vue-router";
import { TypeMyMenuItem } from "./my_menu_type";

import { isExternal } from "util/types";
import { resolvePath } from "@/utils/NslUtil";
import { TypeNslRouteRecord } from "@/utils/util_type";

/**
 * 已经被 create2替代，只做参考
 * 根据 router 中的 RouteRecordRaw[] 生成菜单，todo: 对RouteRecordRaw的类型进行自定义
 * 但未排序
 * @param routes RouteRecordRaw[]
 * @param layerNumber 层数，默认从0开始，函数自己计算，不需要传入
 * @param itemArray 结果数组，传和不传都ok
 * @returns 
 */
function createMenuItemArrayByRoutes(
    routes: RouteRecordRaw[],
    layerNumber: number = 0,
    itemArray: TypeMyMenuItem[]=[],
    
) {
    routes.forEach((rt) => {
        //处理isNavMenu=true的逻辑
        if (rt.meta && rt.meta.isNavMenu) {
        // if (rt) {
            const rtCopy: TypeMyMenuItem = {
                name: rt.name?.toString() + "",
                path: rt.path,
                title: rt.meta?.title as string,
                icon: rt.meta?.icon as string,
                layerNumber: layerNumber,
                layerSort: rt.meta?.layerSort
                    ? new Number(rt.meta?.layerOrder).valueOf()
                    : 99,
            };
            itemArray.push(rtCopy);
            if (rt.children && rt.children.length > 0) {
                rtCopy.children = [];
                createMenuItemArrayByRoutes(
                    rt.children,
                    layerNumber + 1,
                    rtCopy.children,
                );
            }
        }
       
    });

    return itemArray;
}

/**
 * 根据 router 中的 RouteRecordRaw[] 生成菜单，
 * route生成菜单需要满足：
 * 1. meta  2. meta.title  3. isNavMenu=true
 * 思路：
 * 1. 使用fullPath
 * 2. baseFullPath 传递每层的绝对路径
 * 3. parentItem 传递上一层菜单
 * 4. 如果不是nav的话，跳过该层route，但是fullPath依然要处理,爷>父>孙，其中父不是nav，变成 爷>孙
 * 但未排序
 * @param routes RouteRecordRaw[]
 * @param layerNumber 层数，默认从0开始，函数自己计算，不需要传入
 * @param itemArray 结果数组，传和不传都ok
 * @returns 
 */
function createMenuItemArrayByRoutes2(
    routes: TypeNslRouteRecord[],
    layerNumber: number = 0,
    itemArray: TypeMyMenuItem[]=[],
    parentItem?:TypeMyMenuItem,//父元素,
    baseFullPath:string="/"
) {
    routes.forEach((rt) => {
        //处理isNavMenu=true的逻辑
        let fullPath:string;
        if(rt.meta && rt.meta.title){
            //考虑 传入的是 home相对路径 或者 /home 绝对路径
            if(rt.path.indexOf("/")===0){
                fullPath=rt.path
            }else{
                
                fullPath=resolvePath(baseFullPath,rt.path)
            }
           //处理是navMenu的逻辑:rt 加入 菜单
            if(rt.meta.isNavMenu){
                const rtCopy: TypeMyMenuItem = {
                    name: rt.name?.toString() + "",
                    path: rt.path,
                    fullPath,
                    title: rt.meta?.title as string,
                    icon: rt.meta?.icon as string,
                    layerNumber: layerNumber,
                    layerSort: rt.meta.layerSort
                        ? new Number(rt.meta?.layerSort).valueOf()
                        : 99,
                };
                itemArray.push(rtCopy);
                if (rt.children && rt.children.length > 0) {
                    rtCopy.children = [];
                    createMenuItemArrayByRoutes2(
                        rt.children,
                        layerNumber + 1,
                        rtCopy.children,
                        rtCopy,
                        fullPath
                    );
                }
            }else{
                //处理不是navMenu的逻辑:rt 不加入 菜单
                if (rt.children && rt.children.length > 0) {
                    //如果 是第一层route的话，即parentItem=undefined,起子元素直接放置到itemArray中，
                    if(!parentItem){
                        createMenuItemArrayByRoutes2(
                            rt.children,
                            layerNumber + 1,
                            itemArray,
                            parentItem,
                            fullPath
                        );
                    }else{
                        if(!parentItem.children){
                            parentItem.children=[]
                        }
                        createMenuItemArrayByRoutes2(
                            rt.children,
                            layerNumber + 1,
                            parentItem.children,
                            parentItem,
                            fullPath
                        );
                    }
                   
                }
            }
        }
       
    }) 
    return itemArray;
}

/**
 * 排序
 * @param itemArray 
 * @returns 
 */
function orderMenuItemArray(itemArray: TypeMyMenuItem[]) {
    itemArray.sort((pre, next) => {
        return pre.layerSort! - next.layerSort!;
    });
    itemArray.forEach((e) => {
        if (e.children && e.children.length > 0) {
            orderMenuItemArray(e.children);
        }
    });
    return itemArray;
}

/**
 * 根据 router 中的 RouteRecordRaw[] 生成菜单,并排序，
 * todo: 对RouteRecordRaw的类型进行自定义
 * @param routes RouteRecordRaw[]
 * @param layerNumber 层数，默认从0开始
 * @param itemArray 结果数组，传和不传都ok
 * @returns 
 */
function buildMenuItemArray( 
    routes: RouteRecordRaw[],
    layerNumber: number = 0,
    itemArray: TypeMyMenuItem[]=[]
){
    createMenuItemArrayByRoutes(routes,layerNumber,itemArray);
    //orderMenuItemArray(itemArray);
    return itemArray;
}

/**
 * 根据 router 中的 RouteRecordRaw[] 生成菜单,并排序，
 * todo: 对RouteRecordRaw的类型进行自定义
 * @param routes RouteRecordRaw[]
 * @param layerNumber 层数，默认从0开始
 * @param itemArray 结果数组，传和不传都ok
 * @returns 
 */
function buildMenuItemArray2( 
    routes: RouteRecordRaw[],
    layerNumber: number = 0,
    itemArray: TypeMyMenuItem[]=[]
){
    createMenuItemArrayByRoutes2(routes,layerNumber,itemArray);
    orderMenuItemArray(itemArray);
    return itemArray;
}



export {buildMenuItemArray,buildMenuItemArray2}